{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6a5899a2",
   "metadata": {
    "id": "6a5899a2"
   },
   "source": [
    "# 把movie文件夹下的imdb_processed.csv读取，分为训练集和测试集，训练集和测试集的特征，都单独写入一个文件，通过subword-nmt命令进行bpe分词"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f2d80123",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f2d80123",
    "outputId": "90f8bdcf-af13-4552-e4e9-02428cdba30a"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "训练集已保存至 'movie/bpe/train_full.csv'，共 40000 条数据\n",
      "测试集已保存至 'movie/bpe/test_full.csv'，共 10000 条数据\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# 读取数据\n",
    "df = pd.read_csv('movie/imdb_processed.csv')\n",
    "\n",
    "# 分割训练集和测试集\n",
    "train_df, test_df = train_test_split(df, test_size=0.2, random_state=42) # df是源数据，test_size是测试集所占比例，random_state是随机数种子\n",
    "\n",
    "# 创建目录（如果不存在）\n",
    "os.makedirs('movie/bpe', exist_ok=True)\n",
    "\n",
    "# 将训练集和测试集的文本写入文件\n",
    "train_df['processed'].to_csv('movie/bpe/train.txt', index=False, header=False)\n",
    "test_df['processed'].to_csv('movie/bpe/test.txt', index=False, header=False)\n",
    "\n",
    "# 将训练集和测试集完整数据写入文件\n",
    "train_df.to_csv('movie/bpe/train_full.csv', index=False)\n",
    "test_df.to_csv('movie/bpe/test_full.csv', index=False)\n",
    "\n",
    "print(f\"训练集已保存至 'movie/bpe/train_full.csv'，共 {len(train_df)} 条数据\")\n",
    "print(f\"测试集已保存至 'movie/bpe/test_full.csv'，共 {len(test_df)} 条数据\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "cced9810",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cced9810",
    "outputId": "e1afb819-95f7-49d3-cdcc-c83eb49c46c7"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "/content\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2678c093",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2678c093",
    "outputId": "b6a928c8-70e7-44d6-9955-cee9f53d93e1"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "100% 8000/8000 [00:14<00:00, 562.33it/s]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# 使用subword-nmt进行BPE分词\n",
    "# 1. 学习BPE编码（在训练集上）\n",
    "# 学习bpe分词(很慢,学一次就好)\n",
    "# -i 选择学习的文件\n",
    "# -o 核心输出文件,分词需要用到imdb_bpe_code,生成的 imdb_bpe_code 文件包含了学习到的 BPE 操作规则。这些规则用于将单词分割成子词单元\n",
    "# --write-vocabulary 字典输出文件，imdb_bpe_vocab 文件包含了根据 BPE 规则生成的词汇表，列出了所有子词单元及其频率\n",
    "# -s 词表大小\n",
    "# 目的是创建一个BPE编码，将单词分割成子词单元，生成了一个imdb_bpe_code文件\n",
    "!subword-nmt learn-joint-bpe-and-vocab -i ./movie/bpe/train.txt -o ./movie/bpe/imdb_bpe_code --write-vocabulary ./movie/bpe/imdb_bpe_vocab -s 8000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "862fde6c",
   "metadata": {
    "id": "862fde6c"
   },
   "outputs": [],
   "source": [
    "# BPE（Byte Pair Encoding）编码是一种常用的子词分词算法，主要用于将文本中的单词切分为更小的子词单元（subword units）。\n",
    "# 它的基本思想是：通过统计训练语料中最常见的相邻字符对（或子词对），将其合并为新的子词，重复这个过程，直到达到预设的词表大小。\n",
    "# 这样可以有效减少未登录词（OOV）问题，同时兼顾词汇表规模和表达能力。\n",
    "# BPE常用于神经网络NLP任务（如机器翻译、文本分类等）的分词预处理阶段，能提升模型对新词、罕见词的处理能力。\n",
    "# 举一个简单的例子来理解BPE分词的过程：\n",
    "\n",
    "# 假设有如下训练文本：\n",
    "example_text = \"low lower lowest\"\n",
    "\n",
    "# 1. 首先将每个单词拆成字符加上结束符（空格或特殊符号），如：\n",
    "# ['l', 'o', 'w', ' '], ['l', 'o', 'w', 'e', 'r', ' '], ['l', 'o', 'w', 'e', 's', 't', ' ']\n",
    "\n",
    "# 2. 统计所有相邻字符对的频率，合并出现频率最高的对。例如，'l o'、'o w'、'w e'等。\n",
    "# 假设第一次合并 'l o' -> 'lo'，文本变为：\n",
    "# ['lo', 'w', ' '], ['lo', 'w', 'e', 'r', ' '], ['lo', 'w', 'e', 's', 't', ' ']\n",
    "\n",
    "# 3. 继续统计并合并出现频率最高的对，比如 'lo w' -> 'low'，得到：\n",
    "# ['low', ' '], ['low', 'e', 'r', ' '], ['low', 'e', 's', 't', ' ']\n",
    "\n",
    "# 4. 重复这个过程，直到达到预设的词表大小。\n",
    "\n",
    "# 这样，'low'、'lower'、'lowest' 都能被分成已知的子词单元，模型能更好地处理新词和罕见词。\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "pip install subword-nmt"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-PmvRqs0HkQN",
    "outputId": "ab2d8264-4603-4958-9352-43f0f3355bde"
   },
   "id": "-PmvRqs0HkQN",
   "execution_count": 20,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Requirement already satisfied: subword-nmt in /usr/local/lib/python3.11/dist-packages (0.3.8)\n",
      "Requirement already satisfied: mock in /usr/local/lib/python3.11/dist-packages (from subword-nmt) (5.2.0)\n",
      "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from subword-nmt) (4.67.1)\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "eb130500",
   "metadata": {
    "id": "eb130500"
   },
   "outputs": [],
   "source": [
    "# 2. 应用BPE编码到训练集和测试集，生成了train.bpe.txt和test.bpe.txt\n",
    "!subword-nmt apply-bpe -c movie/bpe/imdb_bpe_code -i movie/bpe/train.txt -o movie/bpe/train.bpe.txt\n",
    "!subword-nmt apply-bpe -c movie/bpe/imdb_bpe_code -i movie/bpe/test.txt -o movie/bpe/test.bpe.txt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "672808d4",
   "metadata": {
    "id": "672808d4"
   },
   "outputs": [],
   "source": [
    "# # 3. 获取词汇表\n",
    "# !subword-nmt get-vocab < movie/bpe/imdb_bpe_vocab > movie/bpe/vocab.txt\n",
    "\n",
    "# print(\"BPE处理完成！\")\n",
    "# print(f\"训练集大小: {len(train_df)}\")\n",
    "# print(f\"测试集大小: {len(test_df)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "afee52b3",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "afee52b3",
    "outputId": "a9ac4e01-2c3f-401d-a018-29a392b552a7"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "词典大小: 8105\n",
      "前10个词条: [('[PAD]', 0), ('[BOS]', 1), ('[UNK]', 2), ('[EOS]', 3), ('.', 4), (',', 5), ('I', 6), ('-', 7), ('movie', 8), ('film', 9)]\n"
     ]
    }
   ],
   "source": [
    "# 读取BPE词汇表并构建词典\n",
    "vocab = {}\n",
    "special_tokens = {\n",
    "    \"[PAD]\": 0,  # 填充 token\n",
    "    \"[BOS]\": 1,  # begin of sentence\n",
    "    \"[UNK]\": 2,  # 未知 token\n",
    "    \"[EOS]\": 3,  # end of sentence\n",
    "}\n",
    "\n",
    "# 首先添加特殊标记\n",
    "vocab.update(special_tokens) # 将special_tokens添加到vocab中\n",
    "\n",
    "# 读取BPE词汇表\n",
    "j=len(special_tokens) # 添加特殊标记后，词典大小\n",
    "with open('movie/bpe/imdb_bpe_vocab', 'r', encoding='utf-8') as f:\n",
    "    for i, line in enumerate(f): # 遍历每一行\n",
    "        token, count = line.strip().split(' ') # 去除空格和换行符，并分割成两个部分\n",
    "        if token not in vocab:  # 避免与特殊标记冲突\n",
    "            vocab[token] = j # 添加到词典中\n",
    "            j+=1 # 更新词典大小\n",
    "\n",
    "print(f\"词典大小: {len(vocab)}\")\n",
    "print(f\"前10个词条: {list(vocab.items())[:10]}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9d3ab3fb",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9d3ab3fb",
    "outputId": "8454912b-3c52-403b-b34c-273818611279"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "8101 movie/bpe/imdb_bpe_vocab\n"
     ]
    }
   ],
   "source": [
    "!wc -l movie/bpe/imdb_bpe_vocab"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a747c92",
   "metadata": {
    "id": "3a747c92"
   },
   "source": [
    "# Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88a7ead6",
   "metadata": {
    "id": "88a7ead6"
   },
   "source": [
    "# Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6291049d",
   "metadata": {
    "id": "6291049d"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "# Tokenizer 类,是编码和解码的类\n",
    "class Tokenizer:#\n",
    "    def __init__(self, vocab):\n",
    "        \"\"\"\n",
    "        初始化分词器\n",
    "\n",
    "        参数:\n",
    "            vocab: 词汇表字典，将token映射到ID\n",
    "        \"\"\"\n",
    "        self.vocab = vocab #子词到id的映射\n",
    "        self.id_to_token = {v: k for k, v in vocab.items()} #id到子词的映射\n",
    "        self.pad_id = vocab[\"[PAD]\"] #填充token的id\n",
    "        self.bos_id = vocab[\"[BOS]\"]\n",
    "        self.eos_id = vocab[\"[EOS]\"]\n",
    "        self.unk_id = vocab[\"[UNK]\"]\n",
    "\n",
    "    def encode(self, text_list, max_length=None, padding_first=False):\n",
    "        \"\"\"\n",
    "        将文本编码为ID序列\n",
    "\n",
    "        参数:\n",
    "            text_list: 输入文本列表，可以是单个句子或多个句子\n",
    "            max_length: 最大序列长度，如果指定则会进行截断或填充\n",
    "            padding_first: 如果为True，则在序列前面填充，否则在后面填充\n",
    "\n",
    "        返回:\n",
    "            token_ids: ID序列张量\n",
    "        \"\"\"\n",
    "        # 获取当前批次最大序列长度，+2是因为添加[BOS]和[EOS]的标记\n",
    "        batch_max_length = 2 + max([len(text) for text in text_list]) # 计算当前批次最大序列长度\n",
    "\n",
    "        # max_length为 指定长度 和 批次最大序列长度 取最小值\n",
    "        if batch_max_length <max_length:\n",
    "            max_length = batch_max_length\n",
    "\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            # 转换为ID\n",
    "            indices = [self.bos_id] + [self.vocab.get(token, self.unk_id) for token in text[:max_length-2]] + [self.eos_id]\n",
    "\n",
    "            # 处理填充\n",
    "            if padding_first:  # padding加在前面\n",
    "                # 这行代码的作用是在序列前面填充 [PAD]，填充的数量为 max_length - len(indices)，\n",
    "                # 这样可以保证每个序列的长度都等于 max_length，indices 是原始的 token id 序列。\n",
    "                indices = [self.pad_id] * (max_length - len(indices)) + indices\n",
    "            else:  # padding加在后面\n",
    "                indices = indices + [self.pad_id] * (max_length - len(indices))\n",
    "\n",
    "            indices_list.append(indices) # 把填充后的序列添加到列表中，每个句子都是一个id列表\n",
    "\n",
    "        return torch.tensor(indices_list) # 返回填充后的ID序列张量\n",
    "\n",
    "    def decode(self, token_ids):\n",
    "        \"\"\"\n",
    "        将ID序列解码为文本\n",
    "\n",
    "        参数:\n",
    "            token_ids: ID序列\n",
    "\n",
    "        返回:\n",
    "            text: 解码后的文本\n",
    "        \"\"\"\n",
    "        # 如果输入是张量，则将其转换为列表\n",
    "        if isinstance(token_ids, torch.Tensor):\n",
    "            token_ids = token_ids.tolist()\n",
    "\n",
    "        # 如果输入是二维列表，则递归调用decode方法\n",
    "        # 这行代码用于判断输入的 token_ids 是否为二维列表（即包含多个序列的批量输入）。\n",
    "        # 如果 token_ids[0] 是一个列表，说明 token_ids 是一个嵌套列表（例如 [[1,2,3],[4,5,6]]），\n",
    "        # 代表有多个句子的ID序列。此时，递归地对每个子列表（每个句子的ID序列）分别调用 decode 方法，\n",
    "        # 并将所有解码结果组成一个列表返回，实现批量解码。\n",
    "        if isinstance(token_ids[0], list):\n",
    "            return [self.decode(ids) for ids in token_ids]\n",
    "\n",
    "        tokens = []\n",
    "        for id in token_ids:\n",
    "            if id in [self.pad_id, self.bos_id, self.eos_id]:\n",
    "                continue\n",
    "\n",
    "            token = self.id_to_token.get(id, \"[UNK]\")\n",
    "            tokens.append(token)\n",
    "\n",
    "        # 合并子词\n",
    "        text = \"\"\n",
    "        for token in tokens:\n",
    "            if token.endswith(\"@@\"):\n",
    "                text += token[:-2]  # 移除@@后缀\n",
    "            else:\n",
    "                text += token + \" \"\n",
    "\n",
    "        return text.strip() # 返回解码后的文本，strip() 方法用于移除字符串头尾指定的字符（默认为空格）。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f4c3d2c",
   "metadata": {
    "id": "6f4c3d2c"
   },
   "source": [
    "# Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e865a3e3",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "e865a3e3",
    "outputId": "67a9eb53-9522-470f-81f2-5d9d929562d7"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "/content\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3f79b7bd",
   "metadata": {
    "id": "3f79b7bd"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "import pandas as pd\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    \"\"\"\n",
    "    IMDB数据集类，用于加载和处理IMDB电影评论数据\n",
    "    \"\"\"\n",
    "    def __init__(self, bpe_file, vocab, max_length=512, mode='train'):\n",
    "        \"\"\"\n",
    "        初始化IMDB数据集对象\n",
    "\n",
    "        参数:\n",
    "            bpe_file: BPE处理后的文本文件路径\n",
    "            vocab: 词表\n",
    "            max_length: 最大文本长度\n",
    "            mode: 数据集模式, 可选值为'train'和'test'\n",
    "        \"\"\"\n",
    "\n",
    "        # 读取标签数据\n",
    "        # 只读取前4万行数据\n",
    "        # 根据文件类型决定读取的数据行\n",
    "        if mode == 'train':\n",
    "            # 训练集读取前4万行\n",
    "            self.labels = pd.read_csv('movie/bpe/train_full.csv')['label'].values # 训练集标签\n",
    "        else:\n",
    "            # 测试集读取最后1万行\n",
    "            df = pd.read_csv('movie/bpe/test_full.csv')\n",
    "            self.labels = df.loc[:,'label'].values # 测试集标签\n",
    "\n",
    "        # 读取BPE处理后的文本\n",
    "        self.texts = []\n",
    "        with open(bpe_file, 'r', encoding='utf-8') as f:\n",
    "            self.texts = [line.strip() for line in f]  # 读取每行文本\n",
    "\n",
    "        # 确保文本和标签数量一致\n",
    "        assert len(self.texts) == len(self.labels), \"文本和标签数量不匹配\"\n",
    "\n",
    "        self.tokenizer = Tokenizer(vocab)\n",
    "\n",
    "        self.max_length = max_length\n",
    "\n",
    "    def __len__(self):\n",
    "        \"\"\"返回数据集大小\"\"\"\n",
    "        return len(self.texts)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        \"\"\"\n",
    "        获取指定索引的样本\n",
    "\n",
    "        参数:\n",
    "            idx: 样本索引\n",
    "\n",
    "        返回:\n",
    "            tokens: 分词后的评论文本\n",
    "            label: 情感标签 (0表示负面, 1表示正面)\n",
    "        \"\"\"\n",
    "        # 获取评论文本和标签\n",
    "        text = self.texts[idx]\n",
    "        label = self.labels[idx]\n",
    "\n",
    "        return text.split(), label\n",
    "\n",
    "train_ds = IMDBDataset(bpe_file='movie/bpe/train.bpe.txt',  vocab=vocab, mode='train')\n",
    "test_ds = IMDBDataset(bpe_file='movie/bpe/test.bpe.txt', vocab=vocab, mode='test')\n",
    "\n",
    "# print(train_ds[0])\n",
    "# print(test_ds[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "8e3b8666",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "8e3b8666",
    "outputId": "4b42e93f-ef95-4260-ffbc-79b6dbb68977"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "/tmp/ipython-input-28-1149141991.py:19: UserWarning: Glyph 24179 (\\N{CJK UNIFIED IDEOGRAPH-5E73}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "/tmp/ipython-input-28-1149141991.py:19: UserWarning: Glyph 22343 (\\N{CJK UNIFIED IDEOGRAPH-5747}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "/tmp/ipython-input-28-1149141991.py:19: UserWarning: Glyph 38271 (\\N{CJK UNIFIED IDEOGRAPH-957F}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "/tmp/ipython-input-28-1149141991.py:19: UserWarning: Glyph 24230 (\\N{CJK UNIFIED IDEOGRAPH-5EA6}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "/tmp/ipython-input-28-1149141991.py:19: UserWarning: Glyph 20013 (\\N{CJK UNIFIED IDEOGRAPH-4E2D}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "/tmp/ipython-input-28-1149141991.py:19: UserWarning: Glyph 20301 (\\N{CJK UNIFIED IDEOGRAPH-4F4D}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "/tmp/ipython-input-28-1149141991.py:19: UserWarning: Glyph 25968 (\\N{CJK UNIFIED IDEOGRAPH-6570}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "/tmp/ipython-input-28-1149141991.py:19: UserWarning: Glyph 20998 (\\N{CJK UNIFIED IDEOGRAPH-5206}) missing from font(s) DejaVu Sans.\n",
      "  plt.tight_layout()\n",
      "/usr/local/lib/python3.11/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 24179 (\\N{CJK UNIFIED IDEOGRAPH-5E73}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "/usr/local/lib/python3.11/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 22343 (\\N{CJK UNIFIED IDEOGRAPH-5747}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "/usr/local/lib/python3.11/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 38271 (\\N{CJK UNIFIED IDEOGRAPH-957F}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "/usr/local/lib/python3.11/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 24230 (\\N{CJK UNIFIED IDEOGRAPH-5EA6}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "/usr/local/lib/python3.11/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 20013 (\\N{CJK UNIFIED IDEOGRAPH-4E2D}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "/usr/local/lib/python3.11/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 20301 (\\N{CJK UNIFIED IDEOGRAPH-4F4D}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "/usr/local/lib/python3.11/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 25968 (\\N{CJK UNIFIED IDEOGRAPH-6570}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "/usr/local/lib/python3.11/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 20998 (\\N{CJK UNIFIED IDEOGRAPH-5206}) missing from font(s) DejaVu Sans.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {}
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "最短样本长度: 6\n",
      "最长样本长度: 2749\n",
      "平均样本长度: 199.31\n",
      "样本长度中位数: 147.0\n",
      "样本长度标准差: 155.51\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# 统计训练集中样本的长度分布\n",
    "sample_lengths = [len(train_ds[i][0]) for i in range(len(train_ds))]\n",
    "\n",
    "# 绘制直方图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.hist(sample_lengths, bins=50, alpha=0.7, color='blue')\n",
    "plt.xlabel('Sample Length')\n",
    "plt.ylabel('Sample Count')\n",
    "plt.title('Training Set Sample Length Distribution')\n",
    "plt.grid(True, linestyle='--', alpha=0.7)\n",
    "\n",
    "# 添加一些统计信息\n",
    "plt.axvline(x=np.mean(sample_lengths), color='r', linestyle='--', label=f'平均长度: {np.mean(sample_lengths):.2f}')\n",
    "plt.axvline(x=np.median(sample_lengths), color='g', linestyle='-.', label=f'中位数长度: {np.median(sample_lengths):.2f}')\n",
    "plt.axvline(x=np.percentile(sample_lengths, 95), color='orange', linestyle=':', label=f'95%分位数: {np.percentile(sample_lengths, 95):.2f}')\n",
    "\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# 打印一些统计信息\n",
    "print(f\"最短样本长度: {min(sample_lengths)}\")\n",
    "print(f\"最长样本长度: {max(sample_lengths)}\")\n",
    "print(f\"平均样本长度: {np.mean(sample_lengths):.2f}\")\n",
    "print(f\"样本长度中位数: {np.median(sample_lengths)}\")\n",
    "print(f\"样本长度标准差: {np.std(sample_lengths):.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e718618",
   "metadata": {
    "id": "2e718618"
   },
   "source": [
    "# DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "9e17a21c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9e17a21c",
    "outputId": "0d69c1bb-3940-43ee-a12a-28fffe429ed7"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "训练集DataLoader批次数量: 1250\n",
      "验证集DataLoader批次数量: 313\n",
      "批次中的token_ids形状: torch.Size([32, 500])\n",
      "批次中的标签形状: torch.Size([32, 1])\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "tensor([[   0,    0,    0,  ..., 1977,   14,    3],\n",
       "        [   0,    0,    0,  ..., 1610,   14,    3],\n",
       "        [   0,    0,    0,  ...,    4,   14,    3],\n",
       "        ...,\n",
       "        [   0,    0,    0,  ...,   13,   14,    3],\n",
       "        [   1,   29, 1700,  ...,   35,  606,    3],\n",
       "        [   0,    0,    0,  ...,  585,   14,    3]], dtype=torch.int32)"
      ]
     },
     "metadata": {},
     "execution_count": 29
    }
   ],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch.nn.utils.rnn import pad_sequence\n",
    "\n",
    "tokenizer = Tokenizer(vocab)\n",
    "\n",
    "def collate_fct(batch):\n",
    "    \"\"\"\n",
    "    把字符串列表转化为tensor\n",
    "    :param batch:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    text_list = [item[0] for item in batch] #batch中每个item的第一个元素是text,是输入，类型为list\n",
    "    label_list = [item[1] for item in batch] #batch中每个item的第二个元素是label,是输出，类型为int\n",
    "\n",
    "    text_list = tokenizer.encode(text_list, max_length=500, padding_first=True).to(dtype=torch.int) # padding first是为了统一长度，填充0\n",
    "    # 这句代码的作用是：将文本序列（text_list）和标签（label_list）分别处理后作为一个批次返回。\n",
    "    # 其中，text_list 已经是经过编码和填充的张量；\n",
    "    # label_list 首先被转换为 PyTorch 的张量（torch.tensor(label_list)），\n",
    "    # 然后通过 reshape(-1, 1) 变成二维列向量（方便后续模型处理），\n",
    "    # 最后用 .to(dtype=torch.float) 转为浮点型（通常用于回归或二分类任务）。\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "def create_dataloaders(train_ds,test_ds,batch_size=4):\n",
    "    \"\"\"\n",
    "    创建训练集和验证集的DataLoader\n",
    "\n",
    "    参数:\n",
    "        train_texts: 训练集文本\n",
    "        train_labels: 训练集标签\n",
    "        val_texts: 验证集文本\n",
    "        val_labels: 验证集标签\n",
    "        tokenizer: 分词器\n",
    "        batch_size: 批次大小\n",
    "\n",
    "    返回:\n",
    "        train_dataloader: 训练集DataLoader\n",
    "        val_dataloader: 验证集DataLoader\n",
    "    \"\"\"\n",
    "\n",
    "    # 创建DataLoader\n",
    "    train_dataloader = DataLoader(\n",
    "        train_ds,\n",
    "        batch_size=batch_size,\n",
    "        shuffle=True,\n",
    "        collate_fn=collate_fct\n",
    "    )\n",
    "\n",
    "    val_dataloader = DataLoader(\n",
    "        test_ds,\n",
    "        batch_size=batch_size,\n",
    "        shuffle=False,\n",
    "        collate_fn=collate_fct\n",
    "    )\n",
    "\n",
    "    return train_dataloader, val_dataloader\n",
    "\n",
    "# 调用create_dataloaders函数初始化训练集和测试集的DataLoader\n",
    "batch_size = 32 # 设置批次大小\n",
    "train_dataloader, val_dataloader = create_dataloaders(\n",
    "    train_ds=train_ds,\n",
    "    test_ds=test_ds,\n",
    "    batch_size=batch_size\n",
    ")\n",
    "\n",
    "print(f\"训练集DataLoader批次数量: {len(train_dataloader)}\")\n",
    "print(f\"验证集DataLoader批次数量: {len(val_dataloader)}\")\n",
    "\n",
    "# 查看一个批次的数据样例\n",
    "sample_batch = next(iter(train_dataloader))\n",
    "token_ids, labels = sample_batch\n",
    "print(f\"批次中的token_ids形状: {token_ids.shape}\")\n",
    "print(f\"批次中的标签形状: {labels.shape}\")\n",
    "\n",
    "token_ids"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81586740",
   "metadata": {
    "id": "81586740"
   },
   "source": [
    "# 搭建模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7e28fc1b",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7e28fc1b",
    "outputId": "caf9a8a2-450d-4b90-f119-b2179cd7d00c"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "模型结构:\n",
      "SentimentClassifier(\n",
      "  (embedding): Embedding(8105, 16)\n",
      "  (lstm): LSTM(16, 128, batch_first=True)\n",
      "  (fc1): Linear(in_features=128, out_features=128, bias=True)\n",
      "  (fc): Linear(in_features=128, out_features=1, bias=True)\n",
      "  (dropout): Dropout(p=0.3, inplace=False)\n",
      ")\n",
      "单层单向lstm模型参数数量: 221,073\n",
      "模型已移动到设备: cuda\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class SentimentClassifier(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim=16, hidden_dim=128, output_dim=1,\n",
    "                 lstm_layers=1, bidirectional=False, dropout_rate=0.3):\n",
    "        super().__init__()\n",
    "\n",
    "        # 嵌入层，形状[vocab_size, embedding_dim],输出形状[batch_size, seq_len, embedding_dim]\n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim)\n",
    "\n",
    "        # 设置lstm层，输入形状[batch_size, seq_len, embedding_dim],输出形状[batch_size, seq_len, hidden_dim]\n",
    "        # 输出的hidden_dim是hidden_dim * 2\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim,\n",
    "                         num_layers=lstm_layers, # 层数\n",
    "                         bidirectional=bidirectional, # 是否双向\n",
    "                         batch_first=True,\n",
    "                         dropout=dropout_rate if lstm_layers > 1 else 0)\n",
    "\n",
    "        # 确定输出维度，如果bidirectional为True，则输出维度是hidden_dim * 2\n",
    "        fc_input_dim = hidden_dim * 2 if bidirectional else hidden_dim\n",
    "\n",
    "        # 全连接层，输入形状[batch_size, seq_len, hidden_dim],输出形状[batch_size, hidden_dim]\n",
    "        # 增加一个fc层，输入是fc_input_dim，输出是hidden_dim\n",
    "        self.fc1 = nn.Linear(fc_input_dim, hidden_dim)\n",
    "\n",
    "\n",
    "        # 全连接层，输入形状[batch_size, hidden_dim],输出形状[batch_size, output_dim]\n",
    "        self.fc = nn.Linear(hidden_dim, output_dim)\n",
    "\n",
    "        # Dropout层，防止过拟合\n",
    "        self.dropout = nn.Dropout(dropout_rate)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x形状: [batch_size, seq_len]\n",
    "\n",
    "        # 通过嵌入层\n",
    "        embedded = self.embedding(x)  # [batch_size, seq_len, embedding_dim]\n",
    "\n",
    "        # 通过lstm层，outputs的形状是[batch_size, seq_len, hidden_dim],hidden的形状是[层数*方向, batch_size, hidden_dim]\n",
    "        outputs, hidden = self.lstm(embedded)\n",
    "        # hidden数据类型是tuple\n",
    "        # hidden[0]是h, hidden[1]是c,h是lstm输出的隐藏状态，c是lstm输出的细胞状态\n",
    "        # print(f'outputs.shape: {outputs.shape}')\n",
    "        # print(f'hidden.shape: {hidden.shape}')\n",
    "\n",
    "        # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        # outputs的形状是[batch_size, seq_len, hidden_dim]\n",
    "        x = outputs[:, -1, :]  # 取最后一个时间步的输出\n",
    "        # print(f'hidden: {hidden}') #第一个张量是h, 第二个张量是c\n",
    "        # print(f'len(hidden): {len(hidden)}')\n",
    "        # #输出h，c的形状\n",
    "        # print(f'h是 hidden[0].shape: {hidden[0].shape}')\n",
    "        # print(f'c是 hidden[1].shape: {hidden[1].shape}')\n",
    "        # # # 打印一下形状，观察数据\n",
    "        # print(f'x.shape: {x.shape}')\n",
    "\n",
    "        # hidden_reshaped = hidden[0].squeeze(0)\n",
    "\n",
    "        # # # 判断两个张量是否相等\n",
    "        # is_equal = torch.allclose(x, hidden_reshaped)\n",
    "        # print(f'是否相等: {is_equal}')\n",
    "\n",
    "        # 应用dropout\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.fc(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "# 初始化模型\n",
    "model = SentimentClassifier(vocab_size=len(vocab), lstm_layers=1, bidirectional=False)\n",
    "print(f\"模型结构:\\n{model}\")\n",
    "\n",
    "# 打印模型参数数量\n",
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "print(f\"单层单向lstm模型参数数量: {count_parameters(model):,}\")\n",
    "\n",
    "# 将模型移动到设备上\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = model.to(device)\n",
    "print(f\"模型已移动到设备: {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f6f803c5",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f6f803c5",
    "outputId": "264694ea-8911-4e85-9a95-6a11bf1c390c"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "使用设备: cuda\n",
      "输入形状: torch.Size([32, 500])\n",
      "输出形状: torch.Size([32, 1])\n"
     ]
    }
   ],
   "source": [
    "# 设置设备\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "print(f\"使用设备: {device}\")\n",
    "# 验证模型的前向计算\n",
    "# 从训练数据中获取一个批次的样本\n",
    "sample_batch, sample_labels = next(iter(train_dataloader))\n",
    "print(f\"输入形状: {sample_batch.shape}\")\n",
    "\n",
    "# 将样本移动到设备上\n",
    "sample_batch = sample_batch.to(device)\n",
    "\n",
    "# 进行前向计算\n",
    "with torch.no_grad():\n",
    "    outputs = model(sample_batch)\n",
    "    print(f\"输出形状: {outputs.shape}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbc05baa",
   "metadata": {
    "id": "cbc05baa"
   },
   "source": [
    "# 训练，画图，评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "175bd35f",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 240,
     "referenced_widgets": [
      "24b8f7300b794bc18d9cc6a3c8019811",
      "a03ce6b66f5e48ee85e0cf3bee09c903",
      "0ea20b2be74040a8aad40bb728b5552c",
      "a3b7890ba81e4b0ea1c21ee987463698",
      "ca6d8455309040f78855764efd16284e",
      "57e6e719e98c494a9bb411f87aff0fbc",
      "a2dbfa85a6d14be9a06d810435ca733a",
      "d28d98b1c8c046cd9527f80c211cdc17",
      "6cb74c32af6e41fba682cad80aa8f78a",
      "cd4e7715e1ee4ec49159e918d678fecb",
      "f04677e57505438394d81f6bd36a7c3e"
     ]
    },
    "id": "175bd35f",
    "outputId": "29fba9d4-a653-4edf-86ae-c4e157ee99da"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "模型结构:\n",
      "SentimentClassifier(\n",
      "  (embedding): Embedding(8105, 16)\n",
      "  (lstm): LSTM(16, 128, batch_first=True, bidirectional=True)\n",
      "  (fc1): Linear(in_features=256, out_features=128, bias=True)\n",
      "  (fc): Linear(in_features=128, out_features=1, bias=True)\n",
      "  (dropout): Dropout(p=0.3, inplace=False)\n",
      ")\n",
      "训练开始，共25000步\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "  0%|          | 0/25000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "24b8f7300b794bc18d9cc6a3c8019811"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "早停触发! 最佳验证准确率(如果是回归，这里是损失): 88.2100\n",
      "早停: 在8900 步\n"
     ]
    }
   ],
   "source": [
    "from my_deeplearning_train import train_two_classification_model, evaluate_two_classification_model,plot_learning_curves,EarlyStopping,ModelSaver\n",
    "\n",
    "model = SentimentClassifier(vocab_size=len(vocab), lstm_layers=1, bidirectional=True)\n",
    "print(f\"模型结构:\\n{model}\")\n",
    "\n",
    "# 定义损失函数和优化器，BCEWithLogitsLoss是二分类交叉熵损失函数,是解决二分类问题的\n",
    "criterion = nn.BCEWithLogitsLoss() #BCEWithLogitsLoss代表的含义是：把输出结果通过sigmoid函数，然后计算损失\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 使用Adam优化器\n",
    "# 将模型移动到设备上\n",
    "model = model.to(device)\n",
    "\n",
    "\n",
    "# 训练参数\n",
    "num_epochs = 20 # 训练轮数\n",
    "eval_step = 100 # 评估模型间隔\n",
    "\n",
    "# 训练模型\n",
    "# 创建早停和模型保存器\n",
    "early_stopping = EarlyStopping(patience=10, delta=0.001)\n",
    "model_saver = ModelSaver(save_dir='weights')\n",
    "\n",
    "model, record_dict = train_two_classification_model(\n",
    "    model=model,\n",
    "    train_loader=train_dataloader,\n",
    "    val_loader=val_dataloader,\n",
    "    criterion=criterion,\n",
    "    optimizer=optimizer,\n",
    "    device=device,\n",
    "    num_epochs=num_epochs,\n",
    "    eval_step=eval_step,\n",
    "    early_stopping=early_stopping,\n",
    "    model_saver=model_saver\n",
    ")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d91eae27",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 465
    },
    "id": "d91eae27",
    "outputId": "e9556d53-94e2-4426-8eec-2e351119a96f"
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {}
    }
   ],
   "source": [
    "# 绘制学习曲线\n",
    "plot_learning_curves(record_dict,sample_step=100)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3075fd61",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3075fd61",
    "outputId": "f10924eb-2a0c-4866-ac3d-62a77a753e97"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "测试集准确率: 88.05%, 测试集损失: 0.2962\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# 在测试集上评估最终模型\n",
    "test_acc, test_loss = evaluate_two_classification_model(model, val_dataloader, device, criterion)\n",
    "print(f\"测试集准确率: {test_acc:.2f}%, 测试集损失: {test_loss:.4f}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  },
  "colab": {
   "provenance": [],
   "gpuType": "T4"
  },
  "accelerator": "GPU",
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "24b8f7300b794bc18d9cc6a3c8019811": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "model_module_version": "1.5.0",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_a03ce6b66f5e48ee85e0cf3bee09c903",
       "IPY_MODEL_0ea20b2be74040a8aad40bb728b5552c",
       "IPY_MODEL_a3b7890ba81e4b0ea1c21ee987463698"
      ],
      "layout": "IPY_MODEL_ca6d8455309040f78855764efd16284e"
     }
    },
    "a03ce6b66f5e48ee85e0cf3bee09c903": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "model_module_version": "1.5.0",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_57e6e719e98c494a9bb411f87aff0fbc",
      "placeholder": "​",
      "style": "IPY_MODEL_a2dbfa85a6d14be9a06d810435ca733a",
      "value": " 36%"
     }
    },
    "0ea20b2be74040a8aad40bb728b5552c": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "model_module_version": "1.5.0",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "danger",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_d28d98b1c8c046cd9527f80c211cdc17",
      "max": 25000,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_6cb74c32af6e41fba682cad80aa8f78a",
      "value": 8900
     }
    },
    "a3b7890ba81e4b0ea1c21ee987463698": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "model_module_version": "1.5.0",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_cd4e7715e1ee4ec49159e918d678fecb",
      "placeholder": "​",
      "style": "IPY_MODEL_f04677e57505438394d81f6bd36a7c3e",
      "value": " 8900/25000 [06:12&lt;05:10, 51.84it/s, epoch=7, loss=0.3651, acc=84.38%, val_loss=0.3014, val_acc=87.75%]"
     }
    },
    "ca6d8455309040f78855764efd16284e": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "model_module_version": "1.2.0",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "57e6e719e98c494a9bb411f87aff0fbc": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "model_module_version": "1.2.0",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a2dbfa85a6d14be9a06d810435ca733a": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "model_module_version": "1.5.0",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "d28d98b1c8c046cd9527f80c211cdc17": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "model_module_version": "1.2.0",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "6cb74c32af6e41fba682cad80aa8f78a": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "model_module_version": "1.5.0",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "cd4e7715e1ee4ec49159e918d678fecb": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "model_module_version": "1.2.0",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "f04677e57505438394d81f6bd36a7c3e": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "model_module_version": "1.5.0",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
